/*
	Enum: TextureWrapMode
	
	Clamp - The coord will clamp to the edge.
	Repeat - The texture will repeat over the cord.
*/
enum TextureWrapMode { Clamp, Repeat };
	
/*
	Enum: BlendModes

	Solid - Renders red, green, blue color values and ignores alpha.
	Alpha - Renders all channels normally.
	Light - Source pixels color is added to backbuffer creating a light effect.
	Dark - Source Pixels color is multiplied with backbuffer pixels, creating a darking effect.
*/
enum BlendModes { Solid, Alpha, Light, Dark };

/*
	Enum: AnimationPlaystyle

	None - No play style.
	Once - Plays the animation once.
	Loop - Loops the animation (start -> end, start -> end).
	LoopBack - Loops the animation (start -> end, end -> start).
*/
enum AnimationPlaystyle { None, Once, Loop, LoopBack };

/*
	Function: ClearScreen

	Clears the screen. Note if a viewport has been set, only the viewport area will be
	cleared.
*/
ClearScreen();
/*
	Function: Flip

	Flips the screen buffers. This function should be called after rendering.
*/
Flip();
/*
	Function: SwitchToFullscreen

	Will attempt to make the program full screen, if the width and height
	are support.
	
	See Also:
		
		<SwitchToWindowed>
		<ToggleFullscreen>
*/
SwitchToFullscreen();
/*
	Function: SwitchToWindowed
	
	Will make the program windowed.
	
	See Also:
	
		<SwitchToFullscreen>
		<ToggleFullscreen>
*/
SwitchToWindowed();
/*
	Function: ToggleFullscreen 

	Will toggle between fullscreen and windowed, depening upon current mode.

	See Also:

		<SwitchToFullscreen>
		<SwitchToWindowed>
*/
ToggleFullscreen();
/*
	Function: SetBlendMode

	Sets the current blend mode to use.

	See Also:

		<BlendModes>
		<GetBlendMode>
*/
SetBlendMode(blendMode);
/*
	Function: GetBlendMode

	Gets the current blend mode.

	Returns:

		The current blend mode.

	See Also:

		<BlendModes>
		<SetBlendMode>
*/
GetBlendMode();

/*
	Function: SetGlobalColor

	Sets the current color used when rendering, this function will only effect:

	- DrawLine
	- DrawRect
	- DrawTexture
	- DrawText

	*Color values should range from 0 to 255*

	Parameters:
		
		red - The red value of the color.
		green - The green value of the color.
		blue - The blue value of the color.
		alpha - The alpha value of the color.

	See Also:
		<GetGlobalColorRed>
		<GetGlobalColorGreen>
		<GetGlobalColorBlue>
		<GetGlobalColorAlpha>
*/
SetGlobalColor(red, green, blue, alpha = 255);

/*
	Function: GetGlobalColorRed

	Will return the current global colors, red value.

	Returns:
		
		The red value.

	See Also:

		<SetGlobalColor>
		<GetGlobalColorGreen>
		<GetGlobalColorBlue>
		<GetGlobalColorAlpha>
*/
GetGlobalColorRed();

/*
	Function: GetGlobalColorGreen

	Will return the current global colors, green value.

	Returns:
		
		The green value.

	See Also:

		<SetGlobalColor>
		<GetGlobalColorRed>
		<GetGlobalColorBlue>
		<GetGlobalColorAlpha>
*/
GetGlobalColorGreen();

/*
	Function: GetGlobalColorBlue

	Will return the current global colors, blue value.

	Returns:
		
		The blue value.

	See Also:

		<SetGlobalColor>
		<GetGlobalColorGreen>
		<GetGlobalColorRed>
		<GetGlobalColorAlpha>
*/
GetGlobalColorBlue();
/*
	Function: GetGlobalColorAlpha

	Will return the current global colors, alpha value.

	Returns:
		
		The alpha value.

	See Also:

		<SetGlobalColor>
		<GetGlobalColorGreen>
		<GetGlobalColorBlue>
		<GetGlobalColorRed>
*/
GetGlobalColorAlpha();
/*
	Function: LoadTexture

	Loads a texture from disk. It can also mask out a color, this colors alpha value
	will be set to 0, meaning it will not be visible.

	Texture formats supported:

	- BMP
	- DDS
	- EXR
	- Raw Fax G3
	- GIF
	- HDR
	- ICO
	- IFF
	- JNG
	- JPEG
	- KOALA
	- MNG
	- PCX
	- PBM/PGM/PPM
	- PFM
	- PNG
	- PICT
	- PSD
	- RAW
	- RAS
	- SGI
	- TARGA
	- TIFF
	- WBMP
	- XBM
	- XPM

	Parameters:

		name - Name of the texture in the resource manager.
		filepath - Filepath to the texture.
		maskRed - The red mask value (if -1 is passed, this is ignored)
		maskGreen - The green mask value.
		maskBlue - The blue mask value.
		uTextureWrapMode - The U texture wrap mode (should be TextureWrapMode.Clamp or TextureWrapMode.Repeat)
		vTextureWrapMode - The V texture wrap mode (should be TextureWrapMode.Clamp or TextureWrapMode.Repeat)

	Returns:

		The texture.

	See Also:

		<Texture>
		<UnloadTexture>
		<DrawTexture>
*/
LoadTexture(name, filepath, maskRed = -1, maskGreen = -1, maskBlue = -1, uWrapMode = TextureWrapMode.Clamp, vWrapMode = TextureWrapMode.Clamp);
/*
	Function: UnloadTexture

	Unloads the texture resource.

	Parameters:

		texture - The texture to unload.

	See Also:

		<Texture>
		<LoadTexture>
		<DrawTexture>
*/
UnloadTexture(texture);
/*
	Function: LoadFont

	Loads a true type font, used to draw text to the screen.

	Parameters:
		name - Name of the font in the resource manager.
		filepath - The filepath of the font.
		size - The font size to use.

	Returns:

		The font.

	See Also:

		<Font>
		<UnloadFont>
		<DrawText>
		<TextWidth>
		<TextHeight>
*/
LoadFont(name, filepath, size);
/*
	Function: UnloadFont

	Unloads a font resource.

	Parameters:

		font - The font to unload.

	See Also:

		<Font>
		<LoadFont>
		<DrawText>
		<TextWidth>
		<TextHeight>
*/
UnloadFont(font);
/*
	Function: DrawRect

	Draws a solid rectangle to the screen.

	Parameters:

		x - The x position of the rect.
		y - The y position of the rect.
		width - The width of the rect.
		height - The Height of the rect.
*/
DrawRect(x, y, width, height);
/*
	Function: DrawTexture

	Draws a texture to the screen as a quad.

	Parameters:
		
		texture - The texture to draw.
		x - The x position to draw to.
		y - The y position to draw to.
		width - The width of the quad drawn to (if you pass in -1, the width of the texture will be used)
		height - The height of the quad drawn to (if you pass in -1, the height of the texture will be used)

	See Also:

		<DrawTextureArea>
*/
DrawTexture(texture, x, y, width = -1, height = -1);
/*
	Function: DrawTextureArea

	Draws a sub area of a texture to a quad on the screen.

	Parameters:

		texture - The texture to draw.
		x - The x position to draw to.
		y - The y position to draw to.
		width - The width of the quad drawn to (if you pass in -1, the width of the texture will be used)
		height - The height of the quad drawn to (if you pass in -1, the height of the texture will be used)
		areaX - The x position of the area within the texture (If you pass in -1 then the then the topleft will be used)
		areaY - The y position of the area within the texture (If you pass in -1 then the then the topleft will be used)
		areaWidth - The width of the area within the texture (if you pass in -1, the width of the texture will be used)
		areaHeight - The height of the area within the texture (if you pass in -1, the height of the texture will be used)

	See Also:
		
		<DrawTexture>
*/
DrawTextureArea(texture, x, y, width = -1, height = -1, areaX = -1, areaY = -1, areaWidth = -1, areaHeight = -1);
/*
	Function: DrawText

	Draws the given text to the screen using the font font given.

	Parameters:

		text - The text to render.
		x - The x position to draw to.
		y - The y position to draw to.
		font - The font to use for drawing.

	See Also:

		<Font>
		<TextWidth>
		<TextHeight>
*/
DrawText(text, x, y, font);
/*
	Function: DrawMesh

	Draws the given mesh.

	Parameters:

		mesh - The mesh to render.

	See Also:

		<Mesh>
*/
DrawMesh(mesh);
/*
	Function: DrawCamera

	Draws the given camera. This function will setup the view so that rendering functions
	after it will be as though viewed from this camera. You can use ResetWorld and ResetProjection
	after you are done rendering from this cameras view.

	Parameters:

		camera - The camera to draw.

	See Also:

		<Camera>
		<ResetWorld>
		<ResetProjection>
*/
DrawMesh(mesh);
/*
	Function: DrawSprite

	Draws the given sprite to the screen. You should call ResetWorld after calling this function.

	Parameters:

		sprite - The sprite to draw,

	See Also:

		<Sprite>
		<ResetWorld>
*/
DrawSprite(sprite);
/*
	Function: TextWidth

	Calculates the width, in pixels, of the given text if it were to be rendered using the given font.

	Parameters:

		text - The text to calculate the width of.
		font - The font used for calculation.

	Returns:

		The width, in pixels, calculated.

	See Also:

		<DrawText>
		<TextHeight>
*/
TextWidth(text, font);
/*
	Function: TextHeight

	Calculates the height, in pixels, of the given text if it were to be rendered using the given font.

	Parameters:

		text - The text to calculate the height of.
		font - The font used for calculation.

	Returns:

		The height, in pixels, calculated.

	See Also:

		<DrawText>
		<TextWidth>
*/
TextHeight(text, font);

/*
	Function: BindTexture

	Binds the input texture, if you pass in null it textures will be disabled.

	Parameters:

		Texture - The texture to bind.
*/
BindTexture(texture);

/*
	Function: TranslateWorld

	Translates the world matrix by the given values.

	*This effects all drawing functions*

	Parameters:

		x - The amount along the x axis to translate.
		y - The amount along the y axis to translate.
		z - The amount along the z axis to translate.

	See Also:
		
		<ResetWorld>
		<RotateWorld>
		<ScaleWorld>
		<ProjectX>
		<ProjectY>
*/
TranslateWorld(x, y, z);

/*
	Function: RotateWorldPitch

	Rotates the world matrix about the X-Axis.

	*This effects all drawing functions*

	Parameters:

		angle - The amount to rotate by.

	See Also:

		<ResetWorld>
		<TranslateWorld>
		<ScaleWorld>
		<ProjectX>
		<ProjectY>
*/
RotateWorldPitch(angle);

/*
	Function: RotateWorldYaw

	Rotates the world matrix about the Y-Axis.

	*This effects all drawing functions*

	Parameters:

		angle - The amount to rotate by.

	See Also:

		<ResetWorld>
		<TranslateWorld>
		<ScaleWorld>
		<ProjectX>
		<ProjectY>
*/
RotateWorldYaw(angle);

/*
	Function: RotateWorldRoll

	Rotates the world matrix about the Z-Axis.

	*This effects all drawing functions*

	Parameters:

		angle - The amount to rotate by.

	See Also:

		<ResetWorld>
		<TranslateWorld>
		<ScaleWorld>
		<ProjectX>
		<ProjectY>
*/
RotateWorldRoll(angle);

/*
	Function: ScaleWorld

	Scales the world matrix by the given value.

	*This effects all drawing functions*

	Parameters:

		scaleX - The x scale value.
		scaleY - The y scale value.
		scaleZ - The z scale value.

	See Also:

		<ResetWorld>
		<TranslateWorld>
		<RotateWorld>
		<ProjectX>
		<ProjectY>
*/
ScaleWorld(scaleX, scaleY, scaleZ);
/*
	Function: ResetWorld

	Resets the world matrix.

	*This effects all drawing functions*
*/
ResetWorld();
/*
	Function: ResetProject

	Resets the projection matrix

	*Should be called when done drawing from a camera*
*/
ResetProjection();
/*
	Function: ProjectX

	Attempts to project the given x value into the world matrix and returns the value.

	Returns:

		The projected x value.
*/
ProjectX();
/*
	Function: ProjectY

	Attempts to project the givenyx value into the world matrix and returns the value.

	Returns:

		The projected y value.
*/
ProjectY();
/*
	Function: SetViewport

	Sets a viewport making everything drawn outside of it, black.

	Parameters:
		
		x - The x position of the viewport.
		y - The y position of the viewport.
		width - The width of the viewport.
		height - The height of the viewport.
*/
SetViewport(x, y, width, height);
/*
	Function: GetScreenWidth

	Returns the screen width.

	Returns:

		The screen width.

	See Also:

		<GetScreenHeight>
*/
GetScreenWidth();
/*
	Function: GetScreenHeight

	Returns the screen height.

	Returns:

		The screen height.

	See Also:

		<GetScreenWidth>
*/
GetScreenHeight();

/*
	Function: PushWorldMatrix

	Pushes the world matrix on to the matrix stack.

	See Also:

		<PopWorldMatrix>
*/
PushWorldMatrix();

/*
	Function: PopWorldMatrix

	Pops the last pushed world matrix on to the matrix stack.

	See Also:

		<PushWorldMatrix>
*/
PopWorldMatrix();

/*
	Function: Begin2DRendering

	Setup for 2D rendering.

	See Also:

		<Begin3DRendering>
*/
Begin2DRendering();

/*
	Function: Begin3DRendering

	Setup for 3D rendering.

	See Also:

		<Begin2DRendering>
*/
Begin3DRendering();

/*
	Function: EnableLighting

	Enables lighting.

	See Also:

		<DisableLighting>

*/
EnableLighting();

/*
	Function: DisableLighting

	Disables lighting.

	See Also:

		<EnableLighting>

*/
DisableLighting();

/*
	Class: Texture

	Stores a loaded texture resource.
*/
class Texture
{
	/*
		Function: Load

		Loads a texture resource from disk.

		Parameters:

			name - Name of the texture in the resource manager.
			filepath - Filepath to the texture.
			maskRed - The red mask value (if -1 is passed, this is ignored)
			maskGreen - The green mask value.
			maskBlue - The blue mask value.
			uTextureWrapMode - The U texture wrap mode (should be TextureWrapMode.Clamp or TextureWrapMode.Repeat)
			vTextureWrapMode - The V texture wrap mode (should be TextureWrapMode.Clamp or TextureWrapMode.Repeat)

		See Also:

			<LoadTexture>
	*/
	Load(name, filepath, maskRed = -1, maskGreen = -1, maskBlue = -1, uWrapMode = TextureWrapMode.Clamp, vWrapMode = TextureWrapMode.Clamp);

	/*
		Function: Unload

		Unloads the function resource.

		See Also:

			<UnloadTexture>

	*/
	Unload();

	/*
		Function: GetWidth

		Returns the width of the texture.

		Returns:

			The texture width.
	*/
	GetWidth();

	/*
		Function: GetHeight

		Returns the height of the texture.

		Returns:

			The texture height.
	*/
	GetHeight();

	/*
		Function: GetWidthPow2

		Returns the width of the texture as a power of 2.

		Returns:

			The texture width.
	*/
	GetWidthPow2();

	/*
		Function: GetHeightPow2

		Returns the height of the texture as a power of 2.

		Returns:

			The texture height.
	*/
	GetHeightPow2();

	/*
		Function: GetUOffset

		Returns the U offset for the texture.

		When a texture is loaded, it is actually stored in a texture
		that has dimensions that are a power of 2, because of this
		the actual U end coord of a texture will not be 1.

		Returns:

			The u offset.
	*/
	GetUOffset();

	/*
		Function: GetVOffset

		Returns the V offset for the texture.

		When a texture is loaded, it is actually stored in a texture
		that has dimensions that are a power of 2, because of this
		the actual V end coord of a texture will not be 1.

		Returns:

			The v offset.
	*/
	GetVOffset();
};

/*
	Class: Font

	Stores a font resource.
*/
class
{
	/*
		Function: Load

		Loads a true type font, used to draw text to the screen.

		Parameters:
			name - Name of the font in the resource manager.
			filepath - The filepath of the font.
			size - The font size to use.

		See Also:

			<LoadFont>
	*/
	Load(name, filepath, size);

	/*
		Function: Unload

		Unloads the font resource.

		See Also:
			
			<UnloadFont>
	*/
	Unload();
};

/*
	Class: Mesh

	Stores a mesh resource.
*/
class Mesh
{
	/*
		Constructor: Mesh

		Creates a mesh resource using the given name.

		Parameters:

			name - The name of the mesh resource.
	*/
	constructor (name);

	/*
		Function: Destroy

		Destorys the mesh resource.
	*/
	Destroy();

	/*
		Function: AddVertex

		Adds a vertex to the mesh.

		Parameters:

			x - The x position of the vertex.
			y - The y position of the vertex.
			z - The z position of the vertex.
			u - The u texture position of the vertex.
			v - The v texture position of the vertex.
			red - The red color value of the vertex.
			green - The green color value of the vertex.
			blue - The blue color value of the vertex.
			alpha - The alpha color value of the vertex.
			normalX - The x normal position.
			normalY - The y normal position.
			normalZ - The z normal position.
	*/
	AddVertex(x, y, z, u, v, red = 255, green = 255, blue = 255, alpha = 255, normalX = 0, normalY = 0, normalZ = 0);

	/*
		Function: AddTriangle

		Adds a triangle to the mesh.

		Parameters:

			index0 - The first vertex index making up the triangle.
			index1 - The second vertex index making up the triangle.
			index2 - The third vertex index making up the triangle.
	*/
	AddTriangle(index0, index1, index2);

	/*
		Function: RemoveVertex

		Removes the vertex at the given index.

		Parameters:

			index - The index of the vertex to remove.
	*/
	RemoveVertex(index);

	/*
		Function: RemoveTriangle

		Removes the triangle at the given index.

		Parameters:

			index - The index of the triangle to remove.
	*/
	RemoveTriangle(index);

	/*
		Function: Clear

		Removes all verticies and triangles from the mesh.
	*/
	Clear();

	/*
		Function: Build

		Builds the mesh, making it ready for render.

		*This function should be called anytime you modify the mesh*
	*/
	Build();

	/*
		Function: SetVertexPosition

		Sets the position of the vertex at the given index.

		Parameters:

			index - The vertex index.
			x - The x position to be set.
			y - The y position to be set.
			z - The z position to be set.
	*/
	SetVertexPosition(index, x, y, z = 0);

	/* 
		Function: GetVertexPositionX

		Returns the X position of the vertex at the given index.

		Parameters:

			index - The index of the vertex.

		Returns:

			The X position of the vertex.
	*/
	GetVertexPositionX(index);

	/* 
		Function: GetVertexPositionY

		Returns the Y position of the vertex at the given index.

		Parameters:

			index - The index of the vertex.

		Returns:

			The Y position of the vertex.
	*/
	GetVertexPositionY(index);

	/* 
		Function: GetVertexPositionZ

		Returns the Z position of the vertex at the given index.

		Parameters:

			index - The index of the vertex.

		Returns:

			The Z position of the vertex.
	*/
	GetVertexPositionZ(index);

	/*
		Function: SetVertexTexturePosition

		Sets the texture position of the given vertex index.

		Parameters:

			index - The index of the vertex.
			u - The U texture position.
			v - The V texture position.
	*/
	SetVertexTexturePosition(index, u, v);

	/*
		Function: GetVertexTexturePositionU

		Returns the U texture position of the vertex index.

		Returns:

			The U value.
	*/
	GetVertexTexturePositionU();

	/*
		Function: GetVertexTexturePositionV

		Returns the V texture position of the vertex index.

		Returns:

			The V value.
	*/
	GetVertexTexturePositionV();

	/*
		Function: SetVertexColor

		Sets the color of the given vertex index.

		Parameters:

			index - The index of the vertex.
			red - The red value.
			green - The green value.
			blue - The blue value.
			alpha - The alpha value.
	*/
	SetVertexColor(index, red, green, blue, alpha = 255);

	/*
		Function: GetVertexColorRed

		Returns the red color value of the given vertex index.

		Returns:

			The red value.
	*/
	GetVertexColorRed();

	/*
		Function: GetVertexColorGreen

		Returns the green color value of the given vertex index.

		Returns:

			The green value.
	*/
	GetVertexColorGreen();

	/*
		Function: GetVertexColorBlue

		Returns the blue color value of the given vertex index.

		Returns:

			The blue value.
	*/
	GetVertexColorBlue();

	/*
		Function: GetVertexColorAlpha

		Returns the alpha color value of the given vertex index.

		Returns:

			The alpha value.
	*/
	GetVertexColorAlpha();

	/*
		Function: SetNormalPosition

		Sets the normal of the vertex.

		Parameters:

			index - The vertex index.
			normalX - The x normal to be set.
			normalY - The y normal to be set.
			normalZ - The z normal to be set.
	*/
	SetNormalPosition(index, normalX, normalY, normalZ);

	/* 
		Function: GetVertexNormalX

		Returns the X normal of the vertex at the given index.

		Parameters:

			index - The index of the vertex.

		Returns:

			The X normal of the vertex.
	*/
	GetVertexNormalX(index);

	/* 
		Function: GetVertexPositionY

		Returns the Y position of the vertex at the given index.

		Parameters:

			index - The index of the vertex.

		Returns:

			The Y normal of the vertex.
	*/
	GetVertexNormalY(index);

	/* 
		Function: GetVertexNormalZ

		Returns the Z normal of the vertex at the given index.

		Parameters:

			index - The index of the vertex.

		Returns:

			The Z normal of the vertex.
	*/
	GetVertexNormalZ(index);

	/*
		Function: GetVertexCount

		Returns the number of vertices in the mesh.

		Returns:

			The vertex count.
	*/
	GetVertexCount();

	/*
		Function: GetTriangleCount

		Returns the number of triangles in the mesh.

		Returns:

			The triangle count.
	*/
	GetTriangleCount();

	/*
		Function: NeedsRebuilding

		Checks if the mesh needs to be rebuilt.

		Returns:
			
			True if the mesh should be rebuilt.
	*/
	NeedsRebuilding();
};

/*
	Class: Sprite

	Stores a sprite resource. A sprite is a visual object that can have transformation values, as
	well as an texture. Normally a sprite will only draw a sub section of a texture at a time as
	the texture is a collection of frames. Additionally a sprite can be animated, moving through
	a frame sequence in the animations style.
*/
class Sprite
{
	/*
		Constructor: Sprite

		Creates a new sprite resource.

		Parameters:

			name - The name of sprite resource.
			texture - The texture used to render the sprite.
			frameWidth - The width of a frame.
			frameHeight - The height of a frame.
	*/
	constructor (name, texture, frameWidth, frameHeight);

	/*
		Function: Destroy

		Frees the function resource.
	*/
	Destroy();

	/*
		Function: SetPosition

		Sets the position of the sprite.

		Parameters:

			x - The x position of the sprite.
			y - The y position of the sprite.
	*/
	SetPosition(x, y);

	/*
		Function: GetPositionX

		Returns the x position of the sprite.

		Returns:

			The x position.
	*/
	GetPositionX();

	/*
		Function: GetPositionY

		Returns the y position of the sprite.

		Returns:

			The y position.
	*/
	GetPositionY();

	/*
		Function: SetScale

		Sets the scale of the sprite.

		Parameters:

			scaleX - The x scale value.
			scaleY - The y scale value.
	*/
	SetScale(scaleX, scaleY);

	/*
		Function: GetScaleX

		Returns the x Scale of the sprite.

		Returns:

			The x Scale.
	*/
	GetScaleX();

	/*
		Function: GetScaleY

		Returns the y scale of the sprite.

		Returns:

			The y Scale.
	*/
	GetScaleY();

	/*
		Function: SetRotation

		Sets the rotation of the sprite.

		Parameters:

			rotation - The rotational value, in degrees.
	*/
	SetRotation(rotation);

	/*
		Function: GetRotation

		Returns the rotation of the sprite.

		Returns:

			The rotation value.
	*/
	GetRotation();

	/*
		Function: SetHandlePosition

		Sets the position of the sprites handle. The handle if the offset used when
		drawing the sprite and is a scalar value.

		Parameters:

			handleX - The x handle value.
			handleY - The y handle value.
	*/
	SetHandlePosition(handleX, handleY);

	/*
		Function: GetHandleX

		Returns the x Handle of the sprite.

		Returns:

			The x Handle.
	*/
	GetHandleX();

	/*
		Function: GetHandleY

		Returns the y Handle of the sprite.

		Returns:

			The y Handle.
	*/
	GetHandleY();

	/*
		Function: SetTexture

		Sets the texture used by the sprite.

		Parameters:

			texture - The texture.
	*/
	SetTexture(texture);

	/*
		Function: SetColor

		Sets the color of the sprite.

		Parameters:

			red - The red color value.
			green - The green color value.
			blue - The blue color value.
			alpha - The alpha color value.
	*/
	SetColor(red, green, blue, alpha = 255);

	/*
		Function: GetColorRed

		Returns the red color value.

		Returns:

			The red color value.
	*/
	GetColorRed();

	/*
		Function: GetColorGreen

		Returns the green color value.

		Returns:

			The green color value.
	*/
	GetColorGreen();

	/*
		Function: GetColorBlue

		Returns the blue color value.

		Returns:

			The blue color value.
	*/
	GetColorBlue();

	/*
		Function: GetColorAlpha

		Returns the alpha color value.

		Returns:

			The alpha color value.
	*/
	GetColorAlpha();

	/*
		Function: SetBlendMode

		Sets the blend mode.

		Parameter:

			blendmode - The blend mode.

		See Also:

			<BlendModes>
	*/
	SetBlendMode(blendMode);

	/*
		Function: GetBlendMode

		Returns the blend mode being used by the sprite.

		Returns:

			Returns the current blend mode.

		See Also:

			<BlendModes>
	*/
	GetBlendMode();

	/*
		Function: SetParent

		Sets the sprites parent. If null is passed, then the current parent (if any) is
		unassigned.

		Parameters:
			
			parent - The sprite parent.
	*/
	SetParent(sprite);

	/*
		Function: AddAnimation

		Adds a new animation to the sprite.

		Parameters:

			name - The name of the animation.
			startFrame - The start frame of the animation.
			endFrame - The end frame of the animation.
			fps - The frames per second, this is the speed the animation will play at.
	*/
	AddAnimation(name, startFrame, endFrame, fps);

	/*
		Function: RemoveAnimation

		Removes the named animation from the sprite.

		Parameter:

			name - The name of the animation to remove.
	*/
	RemoveAnimation(name);

	/*
		Function: PlayAnimation

		Plays the named animation.

		Parameters:

			name - The name of the animation to play.
			playstyle - The style to use when playing the animation.

		See All:

			<AnimationPlaystyle>
	*/
	PlayAnimation(name, playstyle);

	/*
		Function: StopAnimation

		Stops the current animation, resetting it.
	*/
	StopAnimation();

	/*
		Function: PauseAnimation

		Pauses the current animation.
	*/
	PauseAnimation();

	/*
		Function: ResumeAnimation

		Resumes the current animation (if there is one).
	*/
	ResumeAnimation();

	/*
		Function: IsAnimationPlaying

		Checks if the named animation is playing. If and empty string given as the
		name, then it will check if the current, active, animation is playing.

		Parameters:

			name - The name of the animation.
	*/
	IsAnimationPlaying(name);

	/*
		Function: GetFrameCountX

		Returns the number of frame that the texture can contain, in the x axis.

		Returns:
			
			The frame count.
	*/
	GetFrameCountX();

	/*
		Function: GetFrameCountY

		Returns the number of frame that the texture can contain, in the y axis.

		Returns:
			
			The frame count.
	*/
	GetFrameCountY();

	/*
		Function: GetFrameCount

		Returns the total number of frames the texture can contain.

		Returns:
			
			The frame count.
	*/
	GetFrameCount();

	/*
		Function: GetFrameWidth

		Gets the width of a single frame.

		Returns:

			The width of a frame.
	*/
	GetFrameWidth();

	/*
		Function: GetFrameHeight

		Gets the height of a single frame.

		Returns:

			The height of a frame.
	*/
	GetFrameHeight();

	/*
		Function: GetWidth

		Gets the width of the sprite as if it was scaled.

		Returns:

			The width.
	*/
	GetWidth();

	/*
		Function: GetHeight

		Gets the height of the sprite as if it was scaled.

		Returns:

			The height.
	*/
	GetHeight();

	/*
		Function: Update

		Updates the sprite. This should be called every update tick of the game.

		Parameters:

			delta - The delta time.
	*/
	Update(delta);
};

/*
	Class: Camera

	Holds a camera resource. A camera can be used to change the view projection and viewport.
*/
class Camera
{
	/*
		Constructor: Camera

		Creates a new camera resource.

		Parameters:
			
			name - The name of the camera resource.
			viewportX - The x position of the cameras viewport.
			viewportY - The y position of the cameras viewport.
			viewportWidth - The width of the cameras viewport.
			viewportHeight - The height of the cameras viewport.
	*/
	constructor (name, viewportX, viewportY, viewportWidth, viewportHeight);

	/*
		Function: Destroy

		Destroys the camera resource
	*/
	Destroy();

	/*
		Function: SetViewport

		Sets the cameras viewport.

		Parameters:
			viewportX - The x position of the cameras viewport.
			viewportY - The y position of the cameras viewport.
			viewportWidth - The width of the cameras viewport.
			viewportHeight - The height of the cameras viewport.
	*/
	SetViewport(viewportX, viewportY, viewportWidth, viewportHeight);

	/*
		Function: SetOrthographicProjection

		Sets the camera up with an orthographic projection.

		When seting up for "traditional" 2D rendering, you should use:
		SetOrthographicProjection(0, GetScreenWidth(), GetScreenHeight(), 0, -1, 1);

		Parameters:
			left - Left plane.
			right - Right plane.
			Top - Top plane.
			Bottom - Bottom plane.
			Near - Near plane.
			Far - Far plane.
	*/
	SetOrthographicProjection(;eft, right, top, bottom, near, far);

	/*
		Function: SetPerspectiveProjection

		Sets the camera up with a perspective projection.

		Parameters:
			fieldOfView - The field of view.
			aspect - The aspect ratio.
			near - The near plane.
			far - The far plane.
	*/
	SetPerspectiveProjection(fieldOfView, aspect, near, far);

	/*
		Function: GetViewportX

		Returns the cameras viewports x position.

		Returns:
			The cameras viewport x position.
	*/
	GetViewportX();

	/*
		Function: GetViewportY

		Returns the cameras viewports y position.

		Returns:
			The cameras viewport y position.
	*/
	GetViewportY();

	/*
		Function: GetViewportWidth

		Returns the cameras viewports width position.

		Returns:
			The cameras viewport width position.
	*/
	GetViewportWidth();

	/*
		Function: GetViewportHeight

		Returns the cameras viewports height position.

		Returns:
			The cameras viewport height position.
	*/
	GetViewportHeight();

	/*
		Function: SetPosition

		Sets the position of the camera.

		Parameters:

			x - The x position of the camera.
			y - The y position of the camera.
			z - The z position of the camera.
	*/
	SetPosition(x, y, z);

	/*
		Function: GetPositionX

		Returns the x position of the camera.

		Returns:

			The x position.
	*/
	GetPositionX();

	/*
		Function: GetPositionY

		Returns the y position of the camera.

		Returns:

			The y position.
	*/
	GetPositionY();

	/*
		Function: GetPositionZ

		Returns the z position of the camera.

		Returns:

			The z position.
	*/
	GetPositionZ();

	/*
		Function: SetScale

		Sets the scale of the camera.

		Parameters:

			scaleX - The x scale value.
			scaleY - The y scale value.
			scaleZ - The z scale value.
	*/
	SetScale(scaleX, scaleY, scaleZ);

	/*
		Function: GetScaleX

		Returns the x Scale of the camera.

		Returns:

			The x Scale.
	*/
	GetScaleX();

	/*
		Function: GetScaleY

		Returns the y scale of the camera.

		Returns:

			The y Scale.
	*/
	GetScaleY();

	/*
		Function: GetScaleZ

		Returns the z scale of the camera.

		Returns:

			The z Scale.
	*/
	GetScaleY();

	/*
		Function: SetPitch

		Sets the pitch of the camera.

		Parameters:

			pitch - The pitch rotational value, in degrees.
	*/
	SetPitch(rotation);

	/*
		Function: SetYaw

		Sets the yaw of the camera.

		Parameters:

			yaw - The yaw rotational value, in degrees.
	*/
	SetYaw(rotation);

	/*
		Function: SetRoll

		Sets the roll of the camera.

		Parameters:

			roll - The roll rotational value, in degrees.
	*/
	SetRoll(rotation);

	/*
		Function: GetPitch

		Returns the pitch of the camera.

		Returns:

			The pitch value.
	*/
	GetPitch();

	/*
		Function: GetYaw

		Returns the yaw of the camera.

		Returns:

			The yaw value.
	*/
	GetYaw();

	/*
		Function: GetRoll

		Returns the roll of the camera.

		Returns:

			The roll value.
	*/
	GetRoll();

	/*
		Function: SetBackgroundColor

		Sets the background color of the camera.

		Parameter:

			red - The red color value.
			green - The green color value.
			blue - The blue color value.
			alpha - The alpha color value.
	*/
	SetBackgroundColor(red, green, blue, alpha = 255);

	/*
		Function: GetBackgroundColorRed

		Returns the background colors red value.

		Returns:

			The red value.
	*/
	GetBackgroundColorRed();

	/*
		Function: GetBackgroundColorGreen

		Returns the background colors green value.

		Returns:

			The green value.
	*/
	GetBackgroundColorGreen();

	/*
		Function: GetBackgroundColorBlue

		Returns the background colors blue value.

		Returns:

			The blue value.
	*/
	GetBackgroundColorBlue();

	/*
		Function: GetBackgroundColorAlpha

		Returns the background colors alpha value.

		Returns:

			The alpha value.
	*/
	GetBackgroundColorAlpha();

	/*
		Function: ProjectX

		Atempts to project the given x value in to the camera and returns its value.

		Returns:
			
			The x value.
	*/
	ProjectX();

	/*
		Function: ProjectY

		Atempts to project the given y value in to the camera and returns its value.

		Returns:
			
			The y value.
	*/
	ProjectY();
};